

//【模板】静态区间和（前缀和）

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(); // 读取数组长度
        int q = in.nextInt(); // 读取查询数量
        ArrayList<Long> arr = new ArrayList<>(n + 1);
        arr.add(0L); // 初始化前缀和数组，第一个元素为0

        // 构建前缀和数组
        for (int i = 1; i <= n; i++) {
            long num = in.nextLong();
            arr.add(arr.get(i - 1) + num);
        }

        StringBuilder result = new StringBuilder();

        // 处理查询
        for (int i = 0; i < q; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            result.append(arr.get(r) - arr.get(l - 1)).append("\n");
        }

        // 输出所有结果
        System.out.print(result);
    }




//【模板】线段树1
    static int N = 100001; // 定义树状数组的最大长度
    static long[] fenwickTree = new long[N]; // 用于存储树状数组的数据
    static long[] arr = new long[N]; // 原始数组，用于存储输入数据

    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(); // 读取数组的长度
        int q = in.nextInt(); // 读取查询的数量

        // 初始化数组并更新树状数组
        for (int i = 1; i <= n; i++) {
            arr[i] = in.nextLong(); // 读取原始数组中的值
            add(i, arr[i]); // 将值添加到树状数组中
        }

        StringBuilder s = new StringBuilder(); // 用于存储查询结果
        for (int i = 0; i < q; i++) {
            int x = in.nextInt(); // 读取操作类型
            if (x == 1) {
                int ai = in.nextInt(); // 读取要更新的索引
                long k = in.nextLong(); // 读取要增加的值
                long delta = k; // 计算变化量
                arr[ai] += delta; // 更新原始数组
                add(ai, delta); // 更新树状数组
            } else {
                int l = in.nextInt(); // 读取区间左端点
                int r = in.nextInt(); // 读取区间右端点
                s.append(sum(r) - sum(l -
                        1)).append('\n'); // 计算区间和并添加到结果中
            }
        }
        System.out.print(s); // 输出所有查询结果
    }

    // 单点更新：将索引 i 处的值增加 delta
    public static void add(int i, long delta) {
        while (i < N) {
            fenwickTree[i] += delta; // 更新当前节点的值
            i += i & -i; // 移动到父节点
        }
    }

    // 前缀和查询：返回从 1 到 i 的累加和
    public static long sum(int i) {
        long res = 0;
        while (i > 0) {
            res += fenwickTree[i]; // 累加当前节点的值
            i -= i & -i; // 移动到子节点
        }
        return res; // 返回前缀和
    }



    //【模板】差分
    public static void main3(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取n和m
        int n = scanner.nextInt();
        int m = scanner.nextInt();

        // 使用long类型存储数组，避免溢出
        long[] arr = new long[n];

        // 读取初始数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();  // 读取到long类型的数组
        }

        // 创建差分数组（也使用long类型）
        long[] delta = new long[n +
                1];  // 需要一个n+1的数组来处理r+1的情况

        // 处理m次操作
        for (int i = 0; i < m; i++) {
            int l = scanner.nextInt() - 1;  // 转换为0-index
            int r = scanner.nextInt() - 1;  // 转换为0-index
            int k = scanner.nextInt();

            delta[l] += k;  // 从l开始加k
            if (r + 1 < n) {
                delta[r + 1] -= k;  // 从r+1开始减k
            }
        }

        // 计算最终结果数组
        long carry = 0;  // 累加的增量
        for (int i = 0; i < n; i++) {
            carry += delta[i];  // 累加当前元素的增量
            arr[i] += carry;  // 更新原数组
        }

        // 输出最终结果
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    //【模板】静态矩阵和（二维前缀和）
    public class Main2 {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            int n=in.nextInt();//长
            int m=in.nextInt();//宽
            int q=in.nextInt();//操作次数
            long[][] arr=new long[n+1][m+1];
            long[][] arrSum=new long[n+1][m+1];

            for(int i=1;i<=n;i++){
                for(int j=1;j<=m;j++){
                    arr[i][j]=in.nextInt();
                }
            }
            for(int i=1;i<=n;i++){
                for(int j=1;j<=m;j++){
                    arrSum[i][j]=arrSum[i-1][j]+arrSum[i][j-1]-arrSum[i-1][j-1]+arr[i][j];
                }
            }

            for(int i=0;i<q;i++){
                int x1=in.nextInt();
                int y1=in.nextInt();
                int x2=in.nextInt();
                int y2=in.nextInt();
                long num = arrSum[x2][y2] - arrSum[x1 - 1][y2] - arrSum[x2][y1 - 1] + arrSum[x1 - 1][y1 - 1];
                System.out.println(num);

            }
        }
    }

    //小红结账
    public static void main4(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(); // 账单数
        int m = in.nextInt(); // 除小红外的总人数

        long[] balance = new long[m + 1]; // 记录每个人要给小红的钱

        for (int i = 0; i < n; i++) {
            int k = in.nextInt(); // 吃饭人数
            long c = in.nextLong(); // 吃饭的总金额

            long num = (c + k - 1) / k; // 正确的向上取整计算

            // 读取 k-1 个人编号，并更新他们的金额
            for (int j = 0; j < k - 1; j++) {
                int a = in.nextInt();
                balance[a] += num;
            }
        }

        // 统一按编号 1~m 输出
        for (int i = 1; i <= m; i++) {
            System.out.print(balance[i] + " ");
        }
    }


    //小红的子序列逆序对
    static final int MOD = 1000000007;
    static final int MAXN = 100005;
    static long[] bit = new long[MAXN]; // 树状数组

    // 树状数组：更新 index 位置的值
    static void update(int index, long value) {
        while (index < MAXN) {
            bit[index] = (bit[index] + value) % MOD;
            index += index & -index;
        }
    }

    // 树状数组：查询小于等于 index 的前缀和
    static long query(int index) {
        long sum = 0;
        while (index > 0) {
            sum = (sum + bit[index]) % MOD;
            index -= index & -index;
        }
        return sum;
    }

    // 快速幂计算 (base^exp) % MOD
    static long fastPow(long base, long exp) {
        long result = 1;
        while (exp > 0) {
            if ((exp & 1) == 1) result = (result * base) % MOD;
            base = (base * base) % MOD;
            exp >>= 1;
        }
        return result;
    }

    public static void main5(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        long[] a = new long[n + 1];
        List<Long> vals = new ArrayList<>();

        for (int i = 1; i <= n; i++) {
            a[i] = scanner.nextLong();
            vals.add(a[i]);
        }

        // 离散化
        Collections.sort(vals);
        vals = new ArrayList<>(new LinkedHashSet<>(vals)); // 去重

        long ans = 0;

        for (int i = n; i >= 1; i--) {
            int idx = Collections.binarySearch(vals, a[i]) + 1; // 离散化索引
            ans = (ans + query(idx - 1)) % MOD; // 查询比当前值小的个数
            update(idx, 1); // 更新 BIT
        }

        ans = (ans * fastPow(2, n - 2)) % MOD; // 乘以 2^(n-2)
        System.out.println(ans);
        scanner.close();
    }
}


